#![allow(dead_code, mutable_transmutes, non_camel_case_types, non_snake_case, non_upper_case_globals, unused_assignments, unused_mut)]
#![feature(extern_types, label_break_value)]
use ::C01Primary::*;
extern "C" {
    pub type _AVLTree;
    pub type _BinaryHeap;
    pub type _BinomialHeap;
    pub type _BloomFilter;
    pub type _HashTable;
    pub type _ListEntry;
    pub type _Queue;
    pub type _Set;
    pub type _SListEntry;
    pub type _Trie;
    fn __assert_fail(
        __assertion: *const libc::c_char,
        __file: *const libc::c_char,
        __line: libc::c_uint,
        __function: *const libc::c_char,
    ) -> !;
    fn int_equal(
        location1: *mut libc::c_void,
        location2: *mut libc::c_void,
    ) -> libc::c_int;
    fn pointer_equal(
        location1: *mut libc::c_void,
        location2: *mut libc::c_void,
    ) -> libc::c_int;
    fn string_equal(
        string1: *mut libc::c_void,
        string2: *mut libc::c_void,
    ) -> libc::c_int;
    fn string_compare(
        string1: *mut libc::c_void,
        string2: *mut libc::c_void,
    ) -> libc::c_int;
    fn int_hash(location: *mut libc::c_void) -> libc::c_uint;
    fn pointer_hash(location: *mut libc::c_void) -> libc::c_uint;
    fn string_hash(string: *mut libc::c_void) -> libc::c_uint;
    fn arraylist_new(length: libc::c_uint) -> *mut ArrayList;
    fn arraylist_free(arraylist: *mut ArrayList);
    fn avl_tree_new(compare_func: AVLTreeCompareFunc) -> *mut AVLTree;
    fn avl_tree_free(tree: *mut AVLTree);
    fn binary_heap_new(
        heap_type: BinaryHeapType,
        compare_func: BinaryHeapCompareFunc,
    ) -> *mut BinaryHeap;
    fn binary_heap_free(heap: *mut BinaryHeap);
    fn binomial_heap_new(
        heap_type: BinomialHeapType,
        compare_func: BinomialHeapCompareFunc,
    ) -> *mut BinomialHeap;
    fn binomial_heap_free(heap: *mut BinomialHeap);
    fn bloom_filter_new(
        table_size: libc::c_uint,
        hash_func: BloomFilterHashFunc,
        num_functions: libc::c_uint,
    ) -> *mut BloomFilter;
    fn bloom_filter_free(bloomfilter: *mut BloomFilter);
    fn hash_table_new(
        hash_func: HashTableHashFunc,
        equal_func: HashTableEqualFunc,
    ) -> *mut HashTable;
    fn hash_table_free(hash_table: *mut HashTable);
    fn list_free(list: *mut ListEntry);
    fn list_prepend(list: *mut *mut ListEntry, data: ListValue) -> *mut ListEntry;
    fn queue_new() -> *mut Queue;
    fn queue_free(queue: *mut Queue);
    fn set_new(hash_func: SetHashFunc, equal_func: SetEqualFunc) -> *mut Set;
    fn set_free(set: *mut Set);
    fn slist_free(list: *mut SListEntry);
    fn slist_prepend(list: *mut *mut SListEntry, data: SListValue) -> *mut SListEntry;
    fn trie_new() -> *mut Trie;
    fn trie_free(trie: *mut Trie);
    fn run_tests(tests_0: *mut UnitTestFunction);
}
pub type ArrayListValue = *mut libc::c_void;
#[derive(Copy, Clone)]
#[repr(C)]
pub struct _ArrayList {
    pub data: *mut ArrayListValue,
    pub length: libc::c_uint,
    pub _alloced: libc::c_uint,
}
pub type ArrayList = _ArrayList;
pub type AVLTree = _AVLTree;
pub type AVLTreeValue = *mut libc::c_void;
pub type AVLTreeCompareFunc = Option::<
    unsafe extern "C" fn(AVLTreeValue, AVLTreeValue) -> libc::c_int,
>;
pub type BinaryHeapType = libc::c_uint;
pub const BINARY_HEAP_TYPE_MAX: BinaryHeapType = 1;
pub const BINARY_HEAP_TYPE_MIN: BinaryHeapType = 0;
pub type BinaryHeapValue = *mut libc::c_void;
pub type BinaryHeapCompareFunc = Option::<
    unsafe extern "C" fn(BinaryHeapValue, BinaryHeapValue) -> libc::c_int,
>;
pub type BinaryHeap = _BinaryHeap;
pub type BinomialHeapType = libc::c_uint;
pub const BINOMIAL_HEAP_TYPE_MAX: BinomialHeapType = 1;
pub const BINOMIAL_HEAP_TYPE_MIN: BinomialHeapType = 0;
pub type BinomialHeapValue = *mut libc::c_void;
pub type BinomialHeapCompareFunc = Option::<
    unsafe extern "C" fn(BinomialHeapValue, BinomialHeapValue) -> libc::c_int,
>;
pub type BinomialHeap = _BinomialHeap;
pub type BloomFilter = _BloomFilter;
pub type BloomFilterValue = *mut libc::c_void;
pub type BloomFilterHashFunc = Option::<
    unsafe extern "C" fn(BloomFilterValue) -> libc::c_uint,
>;
pub type HashTable = _HashTable;
pub type HashTableKey = *mut libc::c_void;
pub type HashTableHashFunc = Option::<
    unsafe extern "C" fn(HashTableKey) -> libc::c_uint,
>;
pub type HashTableEqualFunc = Option::<
    unsafe extern "C" fn(HashTableKey, HashTableKey) -> libc::c_int,
>;
pub type ListEntry = _ListEntry;
pub type ListValue = *mut libc::c_void;
pub type Queue = _Queue;
pub type Set = _Set;
pub type SetValue = *mut libc::c_void;
pub type SetHashFunc = Option::<unsafe extern "C" fn(SetValue) -> libc::c_uint>;
pub type SetEqualFunc = Option::<
    unsafe extern "C" fn(SetValue, SetValue) -> libc::c_int,
>;
pub type SListEntry = _SListEntry;
pub type SListValue = *mut libc::c_void;
pub type Trie = _Trie;
pub type UnitTestFunction = Option::<unsafe extern "C" fn() -> ()>;
unsafe extern "C" fn test_compare_int() {
    let mut a: libc::c_int = 0;
    let mut b: libc::c_int = 0;
    a = 1 as libc::c_int;
    b = 2 as libc::c_int;
    if int_equal(
        &mut a as *mut libc::c_int as *mut libc::c_void,
        &mut b as *mut libc::c_int as *mut libc::c_void,
    ) == 0
    {} else {
        __assert_fail(
            b"!int_equal(&a, &b)\0" as *const u8 as *const libc::c_char,
            b"test-cpp.c\0" as *const u8 as *const libc::c_char,
            54 as libc::c_int as libc::c_uint,
            (*::core::mem::transmute::<
                &[u8; 28],
                &[libc::c_char; 28],
            >(b"void test_compare_int(void)\0"))
                .as_ptr(),
        );
    }
    'c_1854: {
        if int_equal(
            &mut a as *mut libc::c_int as *mut libc::c_void,
            &mut b as *mut libc::c_int as *mut libc::c_void,
        ) == 0
        {} else {
            __assert_fail(
                b"!int_equal(&a, &b)\0" as *const u8 as *const libc::c_char,
                b"test-cpp.c\0" as *const u8 as *const libc::c_char,
                54 as libc::c_int as libc::c_uint,
                (*::core::mem::transmute::<
                    &[u8; 28],
                    &[libc::c_char; 28],
                >(b"void test_compare_int(void)\0"))
                    .as_ptr(),
            );
        }
    };
    a = 2 as libc::c_int;
    b = 2 as libc::c_int;
    if int_equal(
        &mut a as *mut libc::c_int as *mut libc::c_void,
        &mut b as *mut libc::c_int as *mut libc::c_void,
    ) != 0
    {} else {
        __assert_fail(
            b"int_equal(&a, &b)\0" as *const u8 as *const libc::c_char,
            b"test-cpp.c\0" as *const u8 as *const libc::c_char,
            56 as libc::c_int as libc::c_uint,
            (*::core::mem::transmute::<
                &[u8; 28],
                &[libc::c_char; 28],
            >(b"void test_compare_int(void)\0"))
                .as_ptr(),
        );
    }
    'c_1794: {
        if int_equal(
            &mut a as *mut libc::c_int as *mut libc::c_void,
            &mut b as *mut libc::c_int as *mut libc::c_void,
        ) != 0
        {} else {
            __assert_fail(
                b"int_equal(&a, &b)\0" as *const u8 as *const libc::c_char,
                b"test-cpp.c\0" as *const u8 as *const libc::c_char,
                56 as libc::c_int as libc::c_uint,
                (*::core::mem::transmute::<
                    &[u8; 28],
                    &[libc::c_char; 28],
                >(b"void test_compare_int(void)\0"))
                    .as_ptr(),
            );
        }
    };
}
unsafe extern "C" fn test_compare_pointer() {
    let mut a: libc::c_int = 0;
    let mut b: libc::c_int = 0;
    let mut p1: *mut libc::c_void = 0 as *mut libc::c_void;
    let mut p2: *mut libc::c_void = 0 as *mut libc::c_void;
    p1 = &mut a as *mut libc::c_int as *mut libc::c_void;
    p2 = &mut b as *mut libc::c_int as *mut libc::c_void;
    if pointer_equal(p1, p2) == 0 {} else {
        __assert_fail(
            b"!pointer_equal(p1, p2)\0" as *const u8 as *const libc::c_char,
            b"test-cpp.c\0" as *const u8 as *const libc::c_char,
            65 as libc::c_int as libc::c_uint,
            (*::core::mem::transmute::<
                &[u8; 32],
                &[libc::c_char; 32],
            >(b"void test_compare_pointer(void)\0"))
                .as_ptr(),
        );
    }
    'c_1976: {
        if pointer_equal(p1, p2) == 0 {} else {
            __assert_fail(
                b"!pointer_equal(p1, p2)\0" as *const u8 as *const libc::c_char,
                b"test-cpp.c\0" as *const u8 as *const libc::c_char,
                65 as libc::c_int as libc::c_uint,
                (*::core::mem::transmute::<
                    &[u8; 32],
                    &[libc::c_char; 32],
                >(b"void test_compare_pointer(void)\0"))
                    .as_ptr(),
            );
        }
    };
    p1 = &mut a as *mut libc::c_int as *mut libc::c_void;
    p2 = &mut a as *mut libc::c_int as *mut libc::c_void;
    if pointer_equal(p1, p2) != 0 {} else {
        __assert_fail(
            b"pointer_equal(p1, p2)\0" as *const u8 as *const libc::c_char,
            b"test-cpp.c\0" as *const u8 as *const libc::c_char,
            67 as libc::c_int as libc::c_uint,
            (*::core::mem::transmute::<
                &[u8; 32],
                &[libc::c_char; 32],
            >(b"void test_compare_pointer(void)\0"))
                .as_ptr(),
        );
    }
    'c_1919: {
        if pointer_equal(p1, p2) != 0 {} else {
            __assert_fail(
                b"pointer_equal(p1, p2)\0" as *const u8 as *const libc::c_char,
                b"test-cpp.c\0" as *const u8 as *const libc::c_char,
                67 as libc::c_int as libc::c_uint,
                (*::core::mem::transmute::<
                    &[u8; 32],
                    &[libc::c_char; 32],
                >(b"void test_compare_pointer(void)\0"))
                    .as_ptr(),
            );
        }
    };
}
unsafe extern "C" fn test_compare_string() {
    let mut s1: [libc::c_char; 6] = *::core::mem::transmute::<
        &[u8; 6],
        &mut [libc::c_char; 6],
    >(b"hello\0");
    let mut s2: [libc::c_char; 6] = *::core::mem::transmute::<
        &[u8; 6],
        &mut [libc::c_char; 6],
    >(b"hello\0");
    let mut s3: [libc::c_char; 6] = *::core::mem::transmute::<
        &[u8; 6],
        &mut [libc::c_char; 6],
    >(b"world\0");
    if string_equal(
        s1.as_mut_ptr() as *mut libc::c_void,
        s3.as_mut_ptr() as *mut libc::c_void,
    ) == 0
    {} else {
        __assert_fail(
            b"!string_equal(s1, s3)\0" as *const u8 as *const libc::c_char,
            b"test-cpp.c\0" as *const u8 as *const libc::c_char,
            76 as libc::c_int as libc::c_uint,
            (*::core::mem::transmute::<
                &[u8; 31],
                &[libc::c_char; 31],
            >(b"void test_compare_string(void)\0"))
                .as_ptr(),
        );
    }
    'c_2092: {
        if string_equal(
            s1.as_mut_ptr() as *mut libc::c_void,
            s3.as_mut_ptr() as *mut libc::c_void,
        ) == 0
        {} else {
            __assert_fail(
                b"!string_equal(s1, s3)\0" as *const u8 as *const libc::c_char,
                b"test-cpp.c\0" as *const u8 as *const libc::c_char,
                76 as libc::c_int as libc::c_uint,
                (*::core::mem::transmute::<
                    &[u8; 31],
                    &[libc::c_char; 31],
                >(b"void test_compare_string(void)\0"))
                    .as_ptr(),
            );
        }
    };
    if string_equal(
        s1.as_mut_ptr() as *mut libc::c_void,
        s2.as_mut_ptr() as *mut libc::c_void,
    ) != 0
    {} else {
        __assert_fail(
            b"string_equal(s1, s2)\0" as *const u8 as *const libc::c_char,
            b"test-cpp.c\0" as *const u8 as *const libc::c_char,
            77 as libc::c_int as libc::c_uint,
            (*::core::mem::transmute::<
                &[u8; 31],
                &[libc::c_char; 31],
            >(b"void test_compare_string(void)\0"))
                .as_ptr(),
        );
    }
    'c_2039: {
        if string_equal(
            s1.as_mut_ptr() as *mut libc::c_void,
            s2.as_mut_ptr() as *mut libc::c_void,
        ) != 0
        {} else {
            __assert_fail(
                b"string_equal(s1, s2)\0" as *const u8 as *const libc::c_char,
                b"test-cpp.c\0" as *const u8 as *const libc::c_char,
                77 as libc::c_int as libc::c_uint,
                (*::core::mem::transmute::<
                    &[u8; 31],
                    &[libc::c_char; 31],
                >(b"void test_compare_string(void)\0"))
                    .as_ptr(),
            );
        }
    };
}
unsafe extern "C" fn test_hash_int() {
    let mut a: libc::c_int = 0;
    let mut b: libc::c_int = 0;
    a = 1 as libc::c_int;
    b = 2 as libc::c_int;
    if int_hash(&mut a as *mut libc::c_int as *mut libc::c_void)
        != int_hash(&mut b as *mut libc::c_int as *mut libc::c_void)
    {} else {
        __assert_fail(
            b"int_hash(&a) != int_hash(&b)\0" as *const u8 as *const libc::c_char,
            b"test-cpp.c\0" as *const u8 as *const libc::c_char,
            85 as libc::c_int as libc::c_uint,
            (*::core::mem::transmute::<
                &[u8; 25],
                &[libc::c_char; 25],
            >(b"void test_hash_int(void)\0"))
                .as_ptr(),
        );
    }
    'c_2216: {
        if int_hash(&mut a as *mut libc::c_int as *mut libc::c_void)
            != int_hash(&mut b as *mut libc::c_int as *mut libc::c_void)
        {} else {
            __assert_fail(
                b"int_hash(&a) != int_hash(&b)\0" as *const u8 as *const libc::c_char,
                b"test-cpp.c\0" as *const u8 as *const libc::c_char,
                85 as libc::c_int as libc::c_uint,
                (*::core::mem::transmute::<
                    &[u8; 25],
                    &[libc::c_char; 25],
                >(b"void test_hash_int(void)\0"))
                    .as_ptr(),
            );
        }
    };
    a = 2 as libc::c_int;
    b = 2 as libc::c_int;
    if int_hash(&mut a as *mut libc::c_int as *mut libc::c_void)
        == int_hash(&mut b as *mut libc::c_int as *mut libc::c_void)
    {} else {
        __assert_fail(
            b"int_hash(&a) == int_hash(&b)\0" as *const u8 as *const libc::c_char,
            b"test-cpp.c\0" as *const u8 as *const libc::c_char,
            87 as libc::c_int as libc::c_uint,
            (*::core::mem::transmute::<
                &[u8; 25],
                &[libc::c_char; 25],
            >(b"void test_hash_int(void)\0"))
                .as_ptr(),
        );
    }
    'c_2151: {
        if int_hash(&mut a as *mut libc::c_int as *mut libc::c_void)
            == int_hash(&mut b as *mut libc::c_int as *mut libc::c_void)
        {} else {
            __assert_fail(
                b"int_hash(&a) == int_hash(&b)\0" as *const u8 as *const libc::c_char,
                b"test-cpp.c\0" as *const u8 as *const libc::c_char,
                87 as libc::c_int as libc::c_uint,
                (*::core::mem::transmute::<
                    &[u8; 25],
                    &[libc::c_char; 25],
                >(b"void test_hash_int(void)\0"))
                    .as_ptr(),
            );
        }
    };
}
unsafe extern "C" fn test_hash_pointer() {
    let mut a: libc::c_int = 0;
    let mut b: libc::c_int = 0;
    let mut p1: *mut libc::c_void = 0 as *mut libc::c_void;
    let mut p2: *mut libc::c_void = 0 as *mut libc::c_void;
    p1 = &mut a as *mut libc::c_int as *mut libc::c_void;
    p2 = &mut b as *mut libc::c_int as *mut libc::c_void;
    if pointer_hash(p1) != pointer_hash(p2) {} else {
        __assert_fail(
            b"pointer_hash(p1) != pointer_hash(p2)\0" as *const u8
                as *const libc::c_char,
            b"test-cpp.c\0" as *const u8 as *const libc::c_char,
            96 as libc::c_int as libc::c_uint,
            (*::core::mem::transmute::<
                &[u8; 29],
                &[libc::c_char; 29],
            >(b"void test_hash_pointer(void)\0"))
                .as_ptr(),
        );
    }
    'c_2350: {
        if pointer_hash(p1) != pointer_hash(p2) {} else {
            __assert_fail(
                b"pointer_hash(p1) != pointer_hash(p2)\0" as *const u8
                    as *const libc::c_char,
                b"test-cpp.c\0" as *const u8 as *const libc::c_char,
                96 as libc::c_int as libc::c_uint,
                (*::core::mem::transmute::<
                    &[u8; 29],
                    &[libc::c_char; 29],
                >(b"void test_hash_pointer(void)\0"))
                    .as_ptr(),
            );
        }
    };
    p1 = &mut a as *mut libc::c_int as *mut libc::c_void;
    p2 = &mut a as *mut libc::c_int as *mut libc::c_void;
    if pointer_hash(p1) == pointer_hash(p2) {} else {
        __assert_fail(
            b"pointer_hash(p1) == pointer_hash(p2)\0" as *const u8
                as *const libc::c_char,
            b"test-cpp.c\0" as *const u8 as *const libc::c_char,
            98 as libc::c_int as libc::c_uint,
            (*::core::mem::transmute::<
                &[u8; 29],
                &[libc::c_char; 29],
            >(b"void test_hash_pointer(void)\0"))
                .as_ptr(),
        );
    }
    'c_2286: {
        if pointer_hash(p1) == pointer_hash(p2) {} else {
            __assert_fail(
                b"pointer_hash(p1) == pointer_hash(p2)\0" as *const u8
                    as *const libc::c_char,
                b"test-cpp.c\0" as *const u8 as *const libc::c_char,
                98 as libc::c_int as libc::c_uint,
                (*::core::mem::transmute::<
                    &[u8; 29],
                    &[libc::c_char; 29],
                >(b"void test_hash_pointer(void)\0"))
                    .as_ptr(),
            );
        }
    };
}
unsafe extern "C" fn test_hash_string() {
    let mut s1: [libc::c_char; 6] = *::core::mem::transmute::<
        &[u8; 6],
        &mut [libc::c_char; 6],
    >(b"hello\0");
    let mut s2: [libc::c_char; 6] = *::core::mem::transmute::<
        &[u8; 6],
        &mut [libc::c_char; 6],
    >(b"hello\0");
    let mut s3: [libc::c_char; 6] = *::core::mem::transmute::<
        &[u8; 6],
        &mut [libc::c_char; 6],
    >(b"world\0");
    if string_hash(s1.as_mut_ptr() as *mut libc::c_void)
        != string_hash(s3.as_mut_ptr() as *mut libc::c_void)
    {} else {
        __assert_fail(
            b"string_hash(s1) != string_hash(s3)\0" as *const u8 as *const libc::c_char,
            b"test-cpp.c\0" as *const u8 as *const libc::c_char,
            107 as libc::c_int as libc::c_uint,
            (*::core::mem::transmute::<
                &[u8; 28],
                &[libc::c_char; 28],
            >(b"void test_hash_string(void)\0"))
                .as_ptr(),
        );
    }
    'c_2477: {
        if string_hash(s1.as_mut_ptr() as *mut libc::c_void)
            != string_hash(s3.as_mut_ptr() as *mut libc::c_void)
        {} else {
            __assert_fail(
                b"string_hash(s1) != string_hash(s3)\0" as *const u8
                    as *const libc::c_char,
                b"test-cpp.c\0" as *const u8 as *const libc::c_char,
                107 as libc::c_int as libc::c_uint,
                (*::core::mem::transmute::<
                    &[u8; 28],
                    &[libc::c_char; 28],
                >(b"void test_hash_string(void)\0"))
                    .as_ptr(),
            );
        }
    };
    if string_hash(s1.as_mut_ptr() as *mut libc::c_void)
        == string_hash(s2.as_mut_ptr() as *mut libc::c_void)
    {} else {
        __assert_fail(
            b"string_hash(s1) == string_hash(s2)\0" as *const u8 as *const libc::c_char,
            b"test-cpp.c\0" as *const u8 as *const libc::c_char,
            108 as libc::c_int as libc::c_uint,
            (*::core::mem::transmute::<
                &[u8; 28],
                &[libc::c_char; 28],
            >(b"void test_hash_string(void)\0"))
                .as_ptr(),
        );
    }
    'c_2418: {
        if string_hash(s1.as_mut_ptr() as *mut libc::c_void)
            == string_hash(s2.as_mut_ptr() as *mut libc::c_void)
        {} else {
            __assert_fail(
                b"string_hash(s1) == string_hash(s2)\0" as *const u8
                    as *const libc::c_char,
                b"test-cpp.c\0" as *const u8 as *const libc::c_char,
                108 as libc::c_int as libc::c_uint,
                (*::core::mem::transmute::<
                    &[u8; 28],
                    &[libc::c_char; 28],
                >(b"void test_hash_string(void)\0"))
                    .as_ptr(),
            );
        }
    };
}
unsafe extern "C" fn test_arraylist() {
    let mut arraylist: *mut ArrayList = 0 as *mut ArrayList;
    arraylist = arraylist_new(0 as libc::c_int as libc::c_uint);
    arraylist_free(arraylist);
}
unsafe extern "C" fn test_avl_tree() {
    let mut avl_tree: *mut AVLTree = 0 as *mut AVLTree;
    avl_tree = avl_tree_new(
        Some(
            string_compare
                as unsafe extern "C" fn(
                    *mut libc::c_void,
                    *mut libc::c_void,
                ) -> libc::c_int,
        ),
    );
    avl_tree_free(avl_tree);
}
unsafe extern "C" fn test_binary_heap() {
    let mut heap: *mut BinaryHeap = 0 as *mut BinaryHeap;
    heap = binary_heap_new(
        BINARY_HEAP_TYPE_MAX,
        Some(
            string_compare
                as unsafe extern "C" fn(
                    *mut libc::c_void,
                    *mut libc::c_void,
                ) -> libc::c_int,
        ),
    );
    binary_heap_free(heap);
}
unsafe extern "C" fn test_binomial_heap() {
    let mut heap: *mut BinomialHeap = 0 as *mut BinomialHeap;
    heap = binomial_heap_new(
        BINOMIAL_HEAP_TYPE_MAX,
        Some(
            string_compare
                as unsafe extern "C" fn(
                    *mut libc::c_void,
                    *mut libc::c_void,
                ) -> libc::c_int,
        ),
    );
    binomial_heap_free(heap);
}
unsafe extern "C" fn test_bloom_filter() {
    let mut filter: *mut BloomFilter = 0 as *mut BloomFilter;
    filter = bloom_filter_new(
        16 as libc::c_int as libc::c_uint,
        Some(string_hash as unsafe extern "C" fn(*mut libc::c_void) -> libc::c_uint),
        10 as libc::c_int as libc::c_uint,
    );
    bloom_filter_free(filter);
}
unsafe extern "C" fn test_hash_table() {
    let mut hash_table: *mut HashTable = 0 as *mut HashTable;
    hash_table = hash_table_new(
        Some(string_hash as unsafe extern "C" fn(*mut libc::c_void) -> libc::c_uint),
        Some(
            string_equal
                as unsafe extern "C" fn(
                    *mut libc::c_void,
                    *mut libc::c_void,
                ) -> libc::c_int,
        ),
    );
    hash_table_free(hash_table);
}
unsafe extern "C" fn test_list() {
    let mut list: *mut ListEntry = 0 as *mut ListEntry;
    let mut a: libc::c_int = 0;
    let mut b: libc::c_int = 0;
    let mut c: libc::c_int = 0;
    list_prepend(&mut list, &mut a as *mut libc::c_int as ListValue);
    list_prepend(&mut list, &mut b as *mut libc::c_int as ListValue);
    list_prepend(&mut list, &mut c as *mut libc::c_int as ListValue);
    list_free(list);
}
unsafe extern "C" fn test_queue() {
    let mut queue: *mut Queue = 0 as *mut Queue;
    queue = queue_new();
    queue_free(queue);
}
unsafe extern "C" fn test_set() {
    let mut set: *mut Set = 0 as *mut Set;
    set = set_new(
        Some(string_hash as unsafe extern "C" fn(*mut libc::c_void) -> libc::c_uint),
        Some(
            string_equal
                as unsafe extern "C" fn(
                    *mut libc::c_void,
                    *mut libc::c_void,
                ) -> libc::c_int,
        ),
    );
    set_free(set);
}
unsafe extern "C" fn test_slist() {
    let mut list: *mut SListEntry = 0 as *mut SListEntry;
    let mut a: libc::c_int = 0;
    let mut b: libc::c_int = 0;
    let mut c: libc::c_int = 0;
    slist_prepend(&mut list, &mut a as *mut libc::c_int as SListValue);
    slist_prepend(&mut list, &mut b as *mut libc::c_int as SListValue);
    slist_prepend(&mut list, &mut c as *mut libc::c_int as SListValue);
    slist_free(list);
}
unsafe extern "C" fn test_trie() {
    let mut trie: *mut Trie = 0 as *mut Trie;
    trie = trie_new();
    trie_free(trie);
}
static mut tests: [UnitTestFunction; 18] = unsafe {
    [
        Some(test_compare_int as unsafe extern "C" fn() -> ()),
        Some(test_compare_pointer as unsafe extern "C" fn() -> ()),
        Some(test_compare_string as unsafe extern "C" fn() -> ()),
        Some(test_hash_int as unsafe extern "C" fn() -> ()),
        Some(test_hash_pointer as unsafe extern "C" fn() -> ()),
        Some(test_hash_string as unsafe extern "C" fn() -> ()),
        Some(test_arraylist as unsafe extern "C" fn() -> ()),
        Some(test_avl_tree as unsafe extern "C" fn() -> ()),
        Some(test_binary_heap as unsafe extern "C" fn() -> ()),
        Some(test_binomial_heap as unsafe extern "C" fn() -> ()),
        Some(test_bloom_filter as unsafe extern "C" fn() -> ()),
        Some(test_hash_table as unsafe extern "C" fn() -> ()),
        Some(test_list as unsafe extern "C" fn() -> ()),
        Some(test_queue as unsafe extern "C" fn() -> ()),
        Some(test_set as unsafe extern "C" fn() -> ()),
        Some(test_slist as unsafe extern "C" fn() -> ()),
        Some(test_trie as unsafe extern "C" fn() -> ()),
        None,
    ]
};
unsafe fn main_0(
    mut argc: libc::c_int,
    mut argv: *mut *mut libc::c_char,
) -> libc::c_int {
    run_tests(tests.as_mut_ptr());
    return 0;
}
pub fn main() {
    let mut args: Vec::<*mut libc::c_char> = Vec::new();
    for arg in ::std::env::args() {
        args.push(
            (::std::ffi::CString::new(arg))
                .expect("Failed to convert argument into CString.")
                .into_raw(),
        );
    }
    args.push(::core::ptr::null_mut());
    unsafe {
        ::std::process::exit(
            main_0(
                (args.len() - 1) as libc::c_int,
                args.as_mut_ptr() as *mut *mut libc::c_char,
            ) as i32,
        )
    }
}
